};
for ch in name.chars() {
if !ch.is_alphanumeric() && ch != '_' && ch != '-' {
- return Err(human(format!("invalid character in pkgid `{}`: `{}`",
- spec, ch)))
+ bail!("invalid character in pkgid `{}`: `{}`", spec, ch)
}
}
Ok(PackageIdSpec {
fn from_url(mut url: Url) -> CargoResult<PackageIdSpec> {
if url.query.is_some() {
- return Err(human(format!("cannot have a query string in a pkgid: {}",
- url)));
+ bail!("cannot have a query string in a pkgid: {}", url)
}
let frag = url.fragment.take();
let (name, version) = {
let mut ids = i.into_iter().filter(|p| self.matches(*p));
let ret = match ids.next() {
Some(id) => id,
- None => return Err(human(format!("package id specification `{}` \
- matched no packages", self))),
+ None => bail!("package id specification `{}` \
+ matched no packages", self),
};
return match ids.next() {
Some(other) => {
// packages we're visiting and bail if we hit a dupe.
let id = parent.package_id().clone();
if !cx.visited.insert(id.clone()) {
- return Err(human(format!("cyclic package dependency: package `{}` \
- depends on itself", id)))
+ bail!("cyclic package dependency: package `{}` depends on itself", id)
}
// If we're already activated, then that was easy!
None => {
let feat = feat_or_package;
if !visited.insert(feat.to_string()) {
- return Err(human(format!("Cyclic feature dependency: \
- feature `{}` depends on itself",
- feat)))
+ bail!("Cyclic feature dependency: feature `{}` depends \
+ on itself", feat)
}
used.insert(feat.to_string());
match s.features().get(feat) {
for feature in dep.features().iter() {
base.push(feature.clone());
if feature.contains("/") {
- return Err(human(format!("features in dependencies \
- cannot enable features in \
- other dependencies: `{}`",
- feature)));
+ bail!("features in dependencies cannot enable features in \
+ other dependencies: `{}`", feature)
}
}
ret.push((dep.clone(), base));
.collect::<Vec<&str>>();
if unknown.len() > 0 {
let features = unknown.connect(", ");
- return Err(human(format!("Package `{}` does not have these \
- features: `{}`", parent.package_id(),
- features)))
+ bail!("Package `{}` does not have these features: `{}`",
+ parent.package_id(), features)
}
}
use self::Verbosity::{Verbose, Normal, Quiet};
use self::ColorConfig::{Auto, Always, Never};
-use util::errors::{human, CargoResult};
+use util::errors::CargoResult;
#[derive(Clone, Copy, PartialEq)]
pub enum Verbosity {
pub fn set_verbosity(&mut self, verbose: bool, quiet: bool) -> CargoResult<()> {
self.verbosity = match (verbose, quiet) {
- (true, true) => return Err(human("cannot set both --verbose and --quiet")),
+ (true, true) => bail!("cannot set both --verbose and --quiet"),
(true, false) => Verbose,
(false, true) => Quiet,
(false, false) => Normal
None => Auto,
- Some(arg) => return Err(human(format!("argument for --color must be auto, always, or \
- never, but found `{}`",
- arg))),
+ Some(arg) => bail!("argument for --color must be auto, always, or \
+ never, but found `{}`", arg),
});
Ok(())
}
use semver::Version;
use core::{Dependency, PackageId, SourceId};
-use util::{CargoResult, human};
+use util::CargoResult;
/// Subset of a `Manifest`. Contains only the most important informations about
/// a package.
features: HashMap<String, Vec<String>>) -> CargoResult<Summary> {
for dep in dependencies.iter() {
if features.get(dep.name()).is_some() {
- return Err(human(format!("Features and dependencies cannot have \
- the same name: `{}`", dep.name())))
+ bail!("Features and dependencies cannot have the \
+ same name: `{}`", dep.name())
}
if dep.is_optional() && !dep.is_transitive() {
- return Err(human(format!("Dev-dependencies are not allowed \
- to be optional: `{}`",
- dep.name())))
+ bail!("Dev-dependencies are not allowed to be optional: `{}`",
+ dep.name())
}
}
for (feature, list) in features.iter() {
match dependencies.iter().find(|d| d.name() == dep) {
Some(d) => {
if d.is_optional() || is_reexport { continue }
- return Err(human(format!("Feature `{}` depends on `{}` \
- which is not an optional \
- dependency.\nConsider adding \
- `optional = true` to the \
- dependency", feature, dep)))
+ bail!("Feature `{}` depends on `{}` which is not an \
+ optional dependency.\nConsider adding \
+ `optional = true` to the dependency",
+ feature, dep)
}
None if is_reexport => {
- return Err(human(format!("Feature `{}` requires `{}` \
- which is not an optional \
- dependency", feature, dep)))
+ bail!("Feature `{}` requires `{}` which is not an \
+ optional dependency", feature, dep)
}
None => {
- return Err(human(format!("Feature `{}` includes `{}` \
- which is neither a dependency \
- nor another feature",
- feature, dep)))
+ bail!("Feature `{}` includes `{}` which is neither \
+ a dependency nor another feature", feature, dep)
}
}
}
pub use util::{CargoError, CliError, CliResult, human, Config, ChainError};
+macro_rules! bail {
+ ($($fmt:tt)*) => (
+ return Err(::util::human(&format_args!($($fmt)*)))
+ )
+}
+
pub mod core;
pub mod ops;
pub mod sources;
let source_id = root.package_id().source_id();
let resolve = match try!(ops::load_lockfile(&lockfile, source_id)) {
Some(resolve) => resolve,
- None => return Err(human("A Cargo.lock must exist before cleaning"))
+ None => bail!("a Cargo.lock must exist before cleaning")
};
// Create a compilation context to have access to information like target
use core::resolver::{Method, Resolve};
use ops::{self, BuildOutput, ExecEngine};
use util::config::{ConfigValue, Config};
-use util::{CargoResult, internal, human, ChainError, profile};
+use util::{CargoResult, internal, ChainError, profile};
/// Contains information about how a package should be compiled.
pub struct CompileOptions<'a> {
}).map(|s| s.to_string()).collect::<Vec<String>>();
if jobs == Some(0) {
- return Err(human("jobs must be at least 1"))
+ bail!("jobs must be at least 1")
}
let (packages, resolve_with_overrides, sources) = {
};
if spec.len() > 0 && invalid_spec.len() > 0 {
- return Err(human(format!("could not find package matching spec `{}`",
- invalid_spec.connect(", "))));
+ bail!("could not find package matching spec `{}`",
+ invalid_spec.connect(", "))
}
let to_builds = packages.iter().filter(|p| pkgids.contains(&p.package_id()))
profile.rustc_args = Some(args.to_vec());
general_targets.push((target, profile));
} else {
- return Err(human("extra arguments to `rustc` can only be \
- passed to one target, consider \
- filtering\nthe package by passing e.g. \
- `--lib` or `--bin NAME` to specify \
- a single target"))
+ bail!("extra arguments to `rustc` can only be passed to one \
+ target, consider filtering\nthe package by passing \
+ e.g. `--lib` or `--bin NAME` to specify a single target")
}
}
(None, Some(args)) => {
profile.rustdoc_args = Some(args.to_vec());
general_targets.push((target, profile));
} else {
- return Err(human("extra arguments to `rustdoc` can only be \
- passed to one target, consider \
- filtering\nthe package by passing e.g. \
- `--lib` or `--bin NAME` to specify \
- a single target"))
+ bail!("extra arguments to `rustdoc` can only be passed to one \
+ target, consider filtering\nthe package by passing e.g. \
+ `--lib` or `--bin NAME` to specify a single target")
}
}
(None, None) => {
if let Some(t) = pkg.targets().iter().find(|t| t.is_lib()) {
targets.push((t, profile));
} else {
- return Err(human(format!("no library targets found")))
+ bail!("no library targets found")
}
}
});
let t = match target {
Some(t) => t,
- None => return Err(human(format!("no {} target \
- named `{}`",
- desc, name))),
+ None => bail!("no {} target named `{}`", desc, name),
};
debug!("found {} `{}`", desc, name);
targets.push((t, profile));
let cfg_jobs = match try!(config.get_i64("build.jobs")) {
Some((n, p)) => {
if n <= 0 {
- return Err(human(format!("build.jobs must be positive, \
- but found {} in {:?}", n, p)));
+ bail!("build.jobs must be positive, but found {} in {:?}", n, p)
} else if n >= u32::max_value() as i64 {
- return Err(human(format!("build.jobs is too large: \
- found {} in {:?}", n, p)));
+ bail!("build.jobs is too large: found {} in {:?}", n, p)
} else {
Some(n as u32)
}
use core::{Package, PackageIdSpec};
use ops;
-use util::{CargoResult, human};
+use util::CargoResult;
pub struct DocOptions<'a> {
pub open_result: bool,
}
for bin in bin_names.iter() {
if lib_names.contains(bin) {
- return Err(human("Cannot document a package where a library \
- and a binary have the same name. Consider \
- renaming one or marking the target as \
- `doc = false`"))
+ bail!("cannot document a package where a library and a binary \
+ have the same name. Consider renaming one or marking \
+ the target as `doc = false`")
}
}
}
if options.open_result {
let name = if options.compile_opts.spec.len() > 1 {
- return Err(human("Passing multiple packages and `open` is not \
- supported"))
+ bail!("Passing multiple packages and `open` is not supported")
} else if options.compile_opts.spec.len() == 1 {
try!(PackageIdSpec::parse(&options.compile_opts.spec[0]))
.name().replace("-", "_").to_string()
use core::{Resolve, SourceId, Package};
use core::resolver::Method;
use ops;
-use util::config::{Config};
-use util::{CargoResult, human};
+use util::config::Config;
+use util::CargoResult;
pub struct UpdateOptions<'a> {
pub config: &'a Config,
let previous_resolve = match try!(ops::load_pkg_lockfile(&package)) {
Some(resolve) => resolve,
- None => return Err(human("A Cargo.lock must exist before it is updated"))
+ None => bail!("a Cargo.lock must exist before it is updated")
};
if opts.aggressive && opts.precise.is_some() {
- return Err(human("cannot specify both aggressive and precise \
- simultaneously"))
+ bail!("cannot specify both aggressive and precise simultaneously")
}
let mut registry = PackageRegistry::new(opts.config);
None => {
match try!(one(examples, |v| multi_err("examples", v))) {
Some(p) => p,
- None => return Err(human("no packages found with \
- binaries or examples")),
+ None => bail!("no packages found with binaries or \
+ examples"),
}
}
};
// get checked during cargo_compile, we only care about the "build
// everything" case here
if pkg.targets().iter().filter(|t| t.is_bin()).next().is_none() {
- return Err(human("specified package has no binaries"))
+ bail!("specified package has no binaries")
}
for target in pkg.targets().iter().filter(|t| t.is_bin()) {
for bin in installed.get() {
let bin = dst.join(bin);
if fs::metadata(&bin).is_err() {
- return Err(human(format!("corrupt metadata, `{}` does not \
- exist when it should",
- bin.display())))
+ bail!("corrupt metadata, `{}` does not exist when it should",
+ bin.display())
}
}
for bin in bins.iter() {
if !installed.get().contains(bin) {
- return Err(human(format!("binary `{}` not installed as part \
- of `{}`", bin, result)))
+ bail!("binary `{}` not installed as part of `{}`", bin, result)
}
}
pub fn new(opts: NewOptions, config: &Config) -> CargoResult<()> {
let path = config.cwd().join(opts.path);
if fs::metadata(&path).is_ok() {
- return Err(human(format!("Destination `{}` already exists",
- path.display())))
+ bail!("destination `{}` already exists", path.display())
}
let name = match opts.name {
Some(name) => name,
for c in name.chars() {
if c.is_alphanumeric() { continue }
if c == '_' || c == '-' { continue }
- return Err(human(&format!("Invalid character `{}` in crate name: `{}`",
- c, name)));
+ bail!("Invalid character `{}` in crate name: `{}`", c, name)
}
mk(config, &path, name, &opts).chain_error(|| {
human(format!("Failed to create project `{}` at `{}`",
Some(name) => name,
None => {
let username_var = if cfg!(windows) {"USERNAME"} else {"USER"};
- return Err(human(format!("could not determine the current \
- user, please set ${}", username_var)))
+ bail!("could not determine the current user, please set ${}",
+ username_var)
}
};
let email = git_config.and_then(|g| g.get_string("user.email").ok())
dst: &Path) -> CargoResult<()> {
if fs::metadata(&dst).is_ok() {
- return Err(human(format!("destination already exists: {}",
- dst.display())))
+ bail!("destination already exists: {}", dst.display())
}
try!(fs::create_dir_all(dst.parent().unwrap()));
let name = match name.to_str() {
Some(name) => name,
None => {
- return Err(human(format!("path does not have a unicode filename \
- which may not unpack on all platforms: {}",
- file.display())))
+ bail!("path does not have a unicode filename which may not unpack \
+ on all platforms: {}", file.display())
}
};
let bad_chars = ['/', '\\', '<', '>', ':', '"', '|', '?', '*'];
for c in bad_chars.iter().filter(|c| name.contains(**c)) {
- return Err(human(format!("cannot package a filename with a special \
- character `{}`: {}", c, file.display())))
+ bail!("cannot package a filename with a special character `{}`: {}",
+ c, file.display())
}
Ok(())
}
use ops;
use core::{PackageIdSpec, Package};
-use util::{CargoResult, human, Config};
+use util::{CargoResult, Config};
pub fn pkgid(manifest_path: &Path,
spec: Option<&str>,
let source_id = package.package_id().source_id();
let resolve = match try!(ops::load_lockfile(&lockfile, source_id)) {
Some(resolve) => resolve,
- None => return Err(human("A Cargo.lock must exist for this command"))
+ None => bail!("a Cargo.lock must exist for this command"),
};
let pkgid = match spec {
use std::path::Path;
use ops::{self, ExecEngine, CompileFilter};
-use util::{self, CargoResult, human, process, ProcessError};
+use util::{self, CargoResult, process, ProcessError};
use core::Package;
pub fn run(manifest_path: &Path,
if bins.next().is_none() {
match options.filter {
CompileFilter::Everything => {
- return Err(human("a bin target must be available for \
- `cargo run`"))
+ bail!("a bin target must be available for `cargo run`")
}
CompileFilter::Only { .. } => {
// this will be verified in cargo_compile
if bins.next().is_some() {
match options.filter {
CompileFilter::Everything => {
- return Err(human("`cargo run` requires that a project only have \
- one executable; use the `--bin` option to \
- specify which one to run"))
+ bail!("`cargo run` requires that a project only have one \
+ executable; use the `--bin` option to specify which one \
+ to run")
}
CompileFilter::Only { .. } => {
- return Err(human("`cargo run` can run at most one executable, \
- but multiple were specified"))
+ bail!("`cargo run` can run at most one executable, but \
+ multiple were specified")
}
}
}
use core::{TargetKind, LibKind, Profiles, Metadata, Dependency};
use core::dependency::Kind as DepKind;
use util::{self, CargoResult, ChainError, internal, Config, profile};
-use util::human;
use super::TargetConfig;
use super::custom_build::{BuildState, BuildScripts};
(&self.target_triple, &self.target_dylib)
};
match *pair {
- None => return Err(human(format!("dylib outputs are not supported \
- for {}", triple))),
+ None => bail!("dylib outputs are not supported for {}", triple),
Some((ref s1, ref s2)) => Ok((s1, s2)),
}
}
let (key, value) = match (key, value) {
(Some(a), Some(b)) => (a, b.trim_right()),
// line started with `cargo:` but didn't match `key=value`
- _ => return Err(human(format!("Wrong output in {}: `{}`",
- whence, line)))
+ _ => bail!("Wrong output in {}: `{}`", whence, line),
};
match key {
None => break
};
if flag != "-l" && flag != "-L" {
- return Err(human(format!("Only `-l` and `-L` flags are allowed \
- in {}: `{}`",
- whence, value)))
+ bail!("Only `-l` and `-L` flags are allowed in {}: `{}`",
+ whence, value)
}
let value = match flags_iter.next() {
Some(v) => v,
- None => return Err(human(format!("Flag in rustc-flags has no \
- value in {}: `{}`",
- whence, value)))
+ None => bail!("Flag in rustc-flags has no value in {}: `{}`",
+ whence, value)
};
match flag {
"-l" => library_links.push(value.to_string()),
"-L" => library_paths.push(PathBuf::from(value)),
// was already checked above
- _ => return Err(human("only -l and -L flags are allowed"))
+ _ => bail!("only -l and -L flags are allowed")
};
}
Ok((library_paths, library_links))
use std::collections::HashMap;
use core::{PackageId, PackageSet};
-use util::{CargoResult, human};
+use util::CargoResult;
// Validate that there are no duplicated native libraries among packages and
// that all packages with `links` also have a build script.
Some(lib) => lib,
None => continue,
};
- match map.get(&lib) {
- Some(previous) => {
- let depid = dep.package_id();
- if previous.name() == depid.name()
- && previous.source_id() == depid.source_id() {
- return Err(human(format!("native library `{}` is being \
- linked to by more than one \
- version of the same package, but \
- it can only be linked \
- once; try updating \
- or pinning your dependencies to \
- ensure that this package only \
- shows up once\n\n {}\n {}",
- lib, previous, dep.package_id())))
- } else {
- return Err(human(format!("native library `{}` is being \
- linked to by more than one \
- package, and can only be linked \
- to by one package\n\n {}\n {}",
- lib, previous, dep.package_id())))
- }
+ if let Some(prev) = map.get(&lib) {
+ let dep = dep.package_id();
+ if prev.name() == dep.name() && prev.source_id() == dep.source_id() {
+ bail!("native library `{}` is being linked to by more \
+ than one version of the same package, but it can \
+ only be linked once; try updating or pinning your \
+ dependencies to ensure that this package only shows \
+ up once\n\n {}\n {}", lib, prev, dep)
+ } else {
+ bail!("native library `{}` is being linked to by more than \
+ one package, and can only be linked to by one \
+ package\n\n {}\n {}", lib, prev, dep)
}
- None => {}
}
if !dep.manifest().targets().iter().any(|t| t.is_custom_build()) {
- return Err(human(format!("package `{}` specifies that it links to \
- `{}` but does not have a custom build \
- script", dep.package_id(), lib)))
+ bail!("package `{}` specifies that it links to `{}` but does not \
+ have a custom build script", dep.package_id(), lib)
}
map.insert(lib, dep.package_id());
}
for dep in pkg.dependencies().iter() {
if dep.source_id().is_path() {
if dep.specified_req().is_none() {
- return Err(human(format!("all path dependencies must have \
- a version specified when \
- publishing.\n\
- dependency `{}` does not specify \
- a version", dep.name())))
+ bail!("all path dependencies must have a version specified \
+ when publishing.\ndependency `{}` does not specify \
+ a version", dep.name())
}
} else if dep.source_id() != registry_src {
- return Err(human(format!("all dependencies must come from the \
- same source.\ndependency `{}` comes \
- from {} instead", dep.name(),
- dep.source_id())))
+ bail!("all dependencies must come from the same source.\n\
+ dependency `{}` comes from {} instead",
+ dep.name(), dep.source_id())
}
}
Ok(())
match *license_file {
Some(ref file) => {
if fs::metadata(&pkg.root().join(file)).is_err() {
- return Err(human(format!("the license file `{}` does not exist",
- file)))
+ bail!("the license file `{}` does not exist", file)
}
}
None => {}
let api_host = {
let mut src = RegistrySource::new(&sid, config);
try!(src.update().chain_error(|| {
- human(format!("Failed to update registry {}", index))
+ human(format!("failed to update registry {}", index))
}));
(try!(src.config())).api
};
};
let version = match version {
Some(v) => v,
- None => return Err(human("a version must be specified to yank"))
+ None => bail!("a version must be specified to yank")
};
let (mut registry, _) = try!(registry(config, token, index));
// TODO: don't download into memory (curl-rust doesn't expose it)
let resp = try!(handle.get(url.to_string()).follow_redirects(true).exec());
if resp.get_code() != 200 && resp.get_code() != 0 {
- return Err(internal(format!("Failed to get 200 response from {}\n{}",
+ return Err(internal(format!("failed to get 200 response from {}\n{}",
url, resp)))
}
state.finish()
};
if actual.to_hex() != expected_hash {
- return Err(human(format!("Failed to verify the checksum of `{}`",
- pkg)))
+ bail!("failed to verify the checksum of `{}`", pkg)
}
try!(paths::write(&dst, resp.get_body()));
.map(|l| self.parse_registry_package(l))
.collect();
try!(ret.chain_error(|| {
- internal(format!("Failed to parse registry's information \
+ internal(format!("failed to parse registry's information \
for: {}", name))
}))
}
url.path_mut().unwrap().push(package.version().to_string());
url.path_mut().unwrap().push("download".to_string());
let path = try!(self.download_package(package, &url).chain_error(|| {
- internal(format!("Failed to download package `{}` from {}",
+ internal(format!("failed to download package `{}` from {}",
package, url))
}));
let path = try!(self.unpack_package(package, path).chain_error(|| {
- internal(format!("Failed to unpack package `{}`", package))
+ internal(format!("failed to unpack package `{}`", package))
}));
let mut src = PathSource::new(&path, &self.source_id, self.config);
try!(src.update());
let idx = key.split('.').take(i)
.fold(0, |n, s| n + s.len()) + i - 1;
let key_so_far = &key[..idx];
- return Err(human(format!("expected table for configuration \
- key `{}`, but found {} in {}",
- key_so_far, val.desc(),
- path.display())));
+ bail!("expected table for configuration key `{}`, \
+ but found {} in {}",
+ key_so_far, val.desc(), path.display())
}
}
}
Ok((key, value))
}).collect::<CargoResult<_>>()), path.to_path_buf()))
}
- v => return Err(human(format!("found TOML configuration value of \
- unknown type `{}`", v.type_str())))
+ v => bail!("found TOML configuration value of unknown type `{}`",
+ v.type_str()),
}
}
}
}
- Err(human(format!("Could not find `{}` in `{}` or any parent directory",
- file, pwd.display())))
+ bail!("could not find `{}` in `{}` or any parent directory",
+ file, pwd.display())
}
/// Find the root Cargo.toml
Some(path) => {
let absolute_path = cwd.join(&path);
if !absolute_path.ends_with("Cargo.toml") {
- return Err(human("the manifest-path must be a path to a Cargo.toml file"))
+ bail!("the manifest-path must be a path to a Cargo.toml file")
}
if !fs::metadata(&absolute_path).is_ok() {
- return Err(human(format!("manifest path `{}` does not exist", path)))
+ bail!("manifest path `{}` does not exist", path)
}
Ok(absolute_path)
},
None => {}
}
if !manifest.targets().iter().any(|t| !t.is_custom_build()) {
- return Err(human(format!("no targets specified in the manifest\n either \
- src/lib.rs, src/main.rs, a [lib] section, or [[bin]] \
- section must be present")))
+ bail!("no targets specified in the manifest\n \
+ either src/lib.rs, src/main.rs, a [lib] section, or [[bin]] \
+ section must be present")
}
return Ok((manifest, paths));
let project = self.project.as_ref().or_else(|| self.package.as_ref());
let project = try!(project.chain_error(|| {
- human("No `package` or `project` section found.")
+ human("no `package` or `project` section found.")
}));
if project.name.trim().is_empty() {
- return Err(human("package name cannot be an empty string."))
+ bail!("package name cannot be an empty string.")
}
let pkgid = try!(project.to_package_id(source_id));
for bin in bins.iter() {
if blacklist.iter().find(|&x| *x == bin.name()) != None {
- return Err(human(&format!("the binary target name `{}` is \
- forbidden", bin.name())));
+ bail!("the binary target name `{}` is forbidden",
+ bin.name())
}
}
Url::from_file_path(&*p).ok().unwrap()
}
-pub fn cwd() -> PathBuf {
- env::current_dir().unwrap()
-}
-
pub static RUNNING: &'static str = " Running";
pub static COMPILING: &'static str = " Compiling";
pub static DOCUMENTING: &'static str = " Documenting";
failed to parse manifest at `[..]`
Caused by:
- No `package` or `project` section found.
+ no `package` or `project` section found.
"))
});
assert_that(p.cargo_process("build"),
execs().with_status(101)
.with_stderr("\
-Could not find `Cargo.toml` in `[..]` or any parent directory
+could not find `Cargo.toml` in `[..]` or any parent directory
"));
});
assert_that(p.cargo_process("doc"),
execs().with_status(101)
.with_stderr("\
-Cannot document a package where a library and a binary have the same name. \
+cannot document a package where a library and a binary have the same name. \
Consider renaming one or marking the target as `doc = false`
"));
});
fs::create_dir(&dst).unwrap();
assert_that(cargo_process("new").arg("foo"),
execs().with_status(101)
- .with_stderr(format!("Destination `{}` already exists\n",
+ .with_stderr(format!("destination `{}` already exists\n",
dst.display())));
});
unable to get packages from source
Caused by:
- Failed to download package `bad-cksum v0.0.1 (registry file://[..])` from [..]
+ failed to download package `bad-cksum v0.0.1 (registry file://[..])` from [..]
Caused by:
- Failed to verify the checksum of `bad-cksum v0.0.1 (registry file://[..])`
+ failed to verify the checksum of `bad-cksum v0.0.1 (registry file://[..])`
"));
});
.arg("--").arg("--no-defaults"),
execs()
.with_status(101)
- .with_stderr("Cannot document a package where a library and a \
+ .with_stderr("cannot document a package where a library and a \
binary have the same name. Consider renaming one \
or marking the target as `doc = false`"));
});
projects / cargo.git / commitdiff